﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

//********************************************************
//
//                          Week 5
//
//********************************************************
// Auteur: Mathijs Kuijl
// Doel: De randen van een zwart/wit afbeelding inlezen en die vergelijken met eerder opgeslagen data. 
// Gebruik: 1. Het is aan te raden om eerst de MapImage class door te lezen
//          2. Zorg ervoor dat je een data.txt op het bureaublad hebt en dat er data instaat. (kan gedaan worden via MapImage)
//          3. Laad een afbeelding in de gui.
//          4. Run deze classe.
//          5  Bekijk de resultaten in result.txt op je bureaublad
// Notitie: Deze classe heeft nog genoeg mogelijkheden voor uitbreiding. Maar daar is meer tijd voor nodig.
// Mogelijke uitbreidingen:
// - hoeken, hobbels, dallen etc uitrekenen.
// - afwijkingscriteria af laten hangen van de afmetingen van de afbeelding
// 
// Benodigheden: Visual Studio of een ander C# programma
// Aanmaakdatum: 7-3-2012
// Laatste keer bewerkt op: 9-3-2012
// Door: Mathijs Kuijl


namespace THO7AlgoritmTimerApplication {
    class CompareImage : VisionAlgorithm {
        public CompareImage(String name) : base(name) { }
        public override Bitmap DoAlgorithm(Bitmap sourceImage) {

            Bitmap bmpSrc = (Bitmap)sourceImage.Clone();
            BitmapData bmpdata = sourceImage.LockBits(new Rectangle(0, 0, sourceImage.Width, sourceImage.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            IntPtr ptr = bmpdata.Scan0;

            int regellengte = Math.Abs(bmpdata.Stride);
            int bytes = regellengte * sourceImage.Height;
            byte[] rgbValues = new byte[bytes];
            System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);

            List<String> inputRegel = new List<String>();

            inputRegel.Add("filler "); //dit is nodig zodat we niet buiten de lijst vallen tijdens het vergelijken

            //voer een vergelijkbare handeling uit als bij mapimage.
            int pixel;
            int teller = 0;
            for (int convolutie = 0; convolutie < regellengte; convolutie +=3) 
            {
                for (int regelnummer = 0; regelnummer < sourceImage.Height - 1; regelnummer++)
                {
                    pixel = (regelnummer * regellengte) + convolutie;
                    if (rgbValues[pixel] < 25 && rgbValues[pixel + 1] < 25 && rgbValues[pixel + 2] < 25)
                    {
                        break; // stop met zoeken/tellen als zwart is gevonden.
                    }
                    teller++; // tel het aantal stapjes
                }
                inputRegel.Add(teller + " ");
                teller = 0;
            }

            for (int convolutie = regellengte; 0 < convolutie; convolutie -= 3)
            {
                for (int regelnummer = sourceImage.Height; 0 < regelnummer; regelnummer--)
                {
                    pixel = (regelnummer * regellengte) - convolutie;
                    if (rgbValues[pixel] < 25 && rgbValues[pixel - 1] < 25 && rgbValues[pixel - 2] < 25)
                    {
                        break;
                    }
                    teller++;
                }
                inputRegel.Add(teller + " ");
                teller = 0;
            }
            sourceImage.UnlockBits(bmpdata);

            
            string UpDownCo = "";
            for (int i = 0; i < inputRegel.Count; i++)
            {
                UpDownCo += inputRegel[i];
            }
            //StreamWriter writer = new StreamWriter("C:\\Users\\Acer\\Desktop\\CheckIfItWorks.txt", true);
            //writer.WriteLine(UpDownCo);
            //writer.Close();


            //Lees de opgeslagen data in, vergelijk met de data van de huidige afbeelding en maak een schatting.
            StreamWriter Titer = new StreamWriter("C:\\Users\\Acer\\Desktop\\Results.txt", true);
            String line;
            int correct;
            int tel;
            int max = 0;
            string vermoedelijkResultaat = "";
            using (StreamReader sr = new StreamReader(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\Data.txt"))
            {
                while ((line = sr.ReadLine()) != null)
                {
                    tel = 0;
                    correct = 0;
                    string[] ch = line.Split(new Char[] {' '});
                    string[] ch2 = UpDownCo.Split(new Char[] { ' ' });
                    for (int i = 0; i < ch.Length; i++){
                        if (i > 0)
                        {
                            try
                            {
                                float CH1value = Convert.ToInt32(ch[i++]); //omzetten naar int zodat er flexibeler naar gekeken kan worden.
                                float CH2value = Convert.ToInt32(ch2[i++]);
                                if (CH1value <= CH2value +10 && CH1value >= CH2value-10)
                                {
                                    correct++;
                                }
                            }
                            catch (Exception e)
                            {
                            }
                        }
                     }
                    tel++;
                    if (correct > max)
                    {
                        vermoedelijkResultaat = ch[0];
                        max = correct;
                    }
                    Titer.WriteLine("aantal keer dat het overeenkwam:"+ correct);                    
                }
                Titer.WriteLine(" "+vermoedelijkResultaat);
            }
            Titer.Close();
            return sourceImage;
        }
    }
}
